home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Small Islands / Small Islands Gigantic.rmv next >
Encoding:
Text File  |  2001-09-27  |  51.7 KB  |  1,576 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Small Island Gigantic.rmv
  4. //
  5. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  6. // PROPRIETARY and CONFIDENTIAL.
  7. //
  8. // $Author: Scott Marison $
  9. // $Date: 9/06/01 6:46p $
  10. // $Revision: 21 $
  11. // $Revision: 21 $ 
  12. //   Adjusted number of neutrals and percent land
  13. // $Revision: 21 $Revision: 8 
  14. //   Adjusted Angle between team members
  15. // $Revision:
  16. //   Increased # of islands and amount of forest
  17. //  Revision: 10 tweaked land percent
  18. //  Revision: 11 Pushed players and outer neutrals toward the map edge 
  19. //  Revision: 12 Added hills
  20. //  Revision: 13 Lowered hills
  21. //  Revision: 15 Miniaturized
  22. //  Revision: 16 Elevation 
  23. //  Revision: 16.1 Reduced # of islands 
  24. //  Revision: 17 Revised # of resources 3 by 3
  25. //  Revision: 18 8+ player adjustment and enhanced resource placement. 
  26. //  Revision: 19 General Adjustments 
  27. //  Revision: 23 Reduced Resources
  28. //  Revision: 26 Evened-out resource distribution 
  29. //  Revision: 26e Small Islands from Large Islands 
  30. //  Revision: 29 Added gold and iron to 7+ player maps 
  31. //
  32. //////////////////////////////////////////////////////////////////////
  33.  
  34. #if            NOTDEFINED(SMALL_ISLANDS_TINY_RMV)
  35. #define        (SMALL_ISLANDS_TINY_RMV,1)
  36.  
  37. //////////////////////////////////////////////////////////////////////
  38. // Definitions we are required to define for small island maps
  39. //////////////////////////////////////////////////////////////////////
  40.  
  41. ResourcePlacementLimit (Gold,     7,    25)
  42. ResourcePlacementLimit (Steel,     7,     25)
  43. ResourcePlacementLimit (Stone,     7,     25)
  44. ResourcePlacementLimit (Berry,     3,     7)
  45. ResourcePlacementLimit (Fish,     1,    65)
  46. ResourcePlacementLimit (Tree,     4,     10)
  47. ResourcePlacementLimit (Animal,     7,     25)
  48.  
  49.  
  50. #if Is2Players
  51. //////////////////////////////////////////////////////////////////////
  52. // 2 PLAYERS...
  53. //////////////////////////////////////////////////////////////////////
  54.  
  55. //////////////////////////////////////////////////////////////////////
  56. // terrain definitions
  57. #define        (kMinIntElevation,                -10)
  58. #define        (kMaxIntElevation,                9)
  59. #define        (kElevationScale,                      1)
  60. #define        (kPercentLand,                    Between(0.4, 0.4))
  61. #define        (kWaterBorder,                    0)
  62. #define        (kRiverWidth,                    12)
  63. #define        (kCoastToDeepWaterPercentage                1.0)
  64. #define        (kHeightMapChaos,                    Between(10, 15))
  65.         
  66. #define        (kMinimumStartPositionToMapEdge        4)
  67. #define        (kOuterPushFromMapCenter            30)
  68. #define        (kInnerPushFromMapCenter             0)                                
  69.  
  70. //////////////////////////////////////////////////////////////////////
  71. // player definitions
  72. #define        (kMaxAngleBetweenTeamMembers,          55.0)
  73. #define        (kPlayerInnerRadius,            0.7)
  74. #define        (kPlayerOuterRadius,            0.9)
  75. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  76. #define        (kPlayerPercentFlat,            Between(0.7, 0.7))
  77. #define        (kPlayerLandChaos,            0.65)
  78. #define        (kPlayerLandClumps,            1)
  79. #define        (kPlayerFlatChaos,            0.8)
  80. #define        (kPlayerFlatClumps,            1)
  81. #define        (kPlayerTreePercentage,            0.08)
  82.  
  83.  
  84. //////////////////////////////////////////////////////////////////////
  85. // inner neutral definitions
  86. #define        (kNeutralInnerRadius,            0.05)
  87. #define        (kNeutralOuterRadius,            0.54)
  88. #define        (kNeutralOptimalFactor,            0.7)
  89. #define        (kNumInnerNeutrals,            Between(6, 7))
  90. #define        (kInnerNeutralPercentLand,        0.48)
  91. #define        (kInnerNeutralPercentFlat,        Between(.65, .65))
  92. #define        (kInnerNeutralTreePercentage,          0.08)
  93. #define        (kInnerNeutralLandChaos,        0.8)
  94. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  95. #define        (kInnerNeutralFlatChaos,        0.8)
  96. #define        (kInnerNeutralFlatClumps,        1)
  97.  
  98.  
  99. //////////////////////////////////////////////////////////////////////
  100. // outer neutral definitions
  101. #define        (kNumOuterNeutrals,            Between(6, 7))
  102. #define        (kOuterNeutralPercentLand,        0.4)
  103. #define        (kOuterNeutralPercentFlat,        Between(.7, .7))
  104. #define        (kOuterNeutralTreePercentage,          0.08)
  105. #define        (kOuterNeutralLandChaos,        0.8)
  106. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  107. #define        (kOuterNeutralFlatChaos,        0.8)
  108. #define        (kOuterNeutralFlatClumps,        1)
  109.  
  110.  
  111. //////////////////////////////////////////////////////////////////////
  112. // resource definitions
  113. #define        (kMaxResourceElevation,            2)
  114. #define        (kResourceToEdgeDistance,        1)
  115. #define        (kResourceToWaterDistance,        2)
  116.  
  117. #define        (kAnimalPerPlayer,            0)
  118. #define        (kAnimalPerNeutral,            0)
  119.  
  120. #if (IsPaleoEpoch) 
  121.   #define  (kBerryPerPlayer,    2)
  122. #else
  123.   #define  (kBerryPerPlayer,    1)
  124. #endif 
  125. #define        (kBerryPerNeutral,            0)
  126.  
  127. #define        (kFishPerPlayer,                30)
  128. #define        (kFishPerNeutral,                60)
  129.  
  130. #define        (kGoldPerPlayer,                2)
  131. #define        (kGoldPerNeutral,                8)
  132.  
  133. #define        (kOilPerPlayer,                0)
  134. #define        (kOilPerNeutral,                0)
  135.  
  136. #define        (kSteelPerPlayer,                2)
  137. #define        (kSteelPerNeutral,            8)
  138.  
  139. #define        (kStonePerPlayer,                1)
  140. #define        (kStonePerNeutral,            4)
  141.  
  142. #define        (kTreePerPlayer,                1)
  143. #define        (kTreePerNeutral,                0)
  144.  
  145.  
  146. //////////////////////////////////////////////////////////////////////
  147. // forest definitions
  148. #define        (kForestFreeRadius,            9.0)
  149. #define        (kForestsPerPlayer,            4)
  150. #define        (kForestChaosLevel,            0.1)
  151. #define        (kMaxClumpsPerForest,            4)
  152.  
  153.  
  154. #elif Is3Players
  155. //////////////////////////////////////////////////////////////////////
  156. // 3 PLAYERS...
  157. //////////////////////////////////////////////////////////////////////
  158.  
  159. //////////////////////////////////////////////////////////////////////
  160. // terrain definitions
  161. #define        (kMinIntElevation,                -10)
  162. #define        (kMaxIntElevation,                9)
  163. #define        (kElevationScale,                      1)
  164. #define        (kPercentLand,                    Between(0.4, 0.4))
  165. //45% lessens the crowding
  166. #define        (kWaterBorder,                    0)
  167. #define        (kRiverWidth,                    12)
  168. #define        (kCoastToDeepWaterPercentage                1.0)
  169. #define        (kHeightMapChaos,                    Between(10, 15))
  170.         
  171. #define        (kMinimumStartPositionToMapEdge        4)
  172. #define        (kOuterPushFromMapCenter            40)
  173. #define        (kInnerPushFromMapCenter             0)
  174.  
  175. //////////////////////////////////////////////////////////////////////
  176. // player definitions
  177. #define        (kMaxAngleBetweenTeamMembers,          55.0)
  178. #define        (kPlayerInnerRadius,            0.7)
  179. #define        (kPlayerOuterRadius,            0.99)
  180. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  181. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  182. #define        (kPlayerLandChaos,            0.8)
  183. #define        (kPlayerLandClumps,            1)
  184. #define        (kPlayerFlatChaos,            0.8)
  185. #define        (kPlayerFlatClumps,            1)
  186. #define        (kPlayerTreePercentage,            0.08)
  187.  
  188.  
  189. //////////////////////////////////////////////////////////////////////
  190. // inner neutral definitions
  191. #define        (kNeutralInnerRadius,            0.05)
  192. #define        (kNeutralOuterRadius,            0.54)
  193. #define        (kNeutralOptimalFactor,            0.7)
  194. #define        (kNumInnerNeutrals,            Between(6, 7))
  195. #define        (kInnerNeutralPercentLand,        0.43)
  196. #define        (kInnerNeutralPercentFlat,        Between(.7, .7))
  197. #define        (kInnerNeutralTreePercentage,          0.08)
  198. #define        (kInnerNeutralLandChaos,        0.8)
  199. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  200. #define        (kInnerNeutralFlatChaos,        0.8)
  201. #define        (kInnerNeutralFlatClumps,        1)
  202.  
  203.  
  204. //////////////////////////////////////////////////////////////////////
  205. // outer neutral definitions
  206. #define        (kNumOuterNeutrals,            Between(5, 6))
  207. #define        (kOuterNeutralPercentLand,        0.36)
  208. #define        (kOuterNeutralPercentFlat,        Between(.7, .7))
  209. #define        (kOuterNeutralTreePercentage,          0.08)
  210. #define        (kOuterNeutralLandChaos,        0.8)
  211. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  212. #define        (kOuterNeutralFlatChaos,        0.8)
  213. #define        (kOuterNeutralFlatClumps,        1)
  214.  
  215.  
  216. //////////////////////////////////////////////////////////////////////
  217. // resource definitions
  218. #define        (kMaxResourceElevation,            2)
  219. #define        (kResourceToEdgeDistance,        1)
  220. #define        (kResourceToWaterDistance,        2)
  221.  
  222. #define        (kAnimalPerPlayer,            0)
  223. #define        (kAnimalPerNeutral,            0)
  224.  
  225. #if (IsPaleoEpoch) 
  226.   #define  (kBerryPerPlayer,    2)
  227. #else
  228.   #define  (kBerryPerPlayer,    1)
  229. #endif 
  230. #define        (kBerryPerNeutral,            0)
  231.  
  232. #define        (kFishPerPlayer,                27)
  233. #define        (kFishPerNeutral,                50)
  234.  
  235. #define        (kGoldPerPlayer,                2)
  236. #define        (kGoldPerNeutral,                11)
  237.  
  238. #define        (kOilPerPlayer,                0)
  239. #define        (kOilPerNeutral,                0)
  240.  
  241. #define        (kSteelPerPlayer,                2)
  242. #define        (kSteelPerNeutral,            11)
  243.  
  244. #define        (kStonePerPlayer,                1)
  245. #define        (kStonePerNeutral,            5)
  246.  
  247. #define        (kTreePerPlayer,                1)
  248. #define        (kTreePerNeutral,                0)
  249.  
  250.  
  251. //////////////////////////////////////////////////////////////////////
  252. // forest definitions
  253. #define        (kForestFreeRadius,            8.0)
  254. #define        (kForestsPerPlayer,            4)
  255. #define        (kForestChaosLevel,            0.1)
  256. #define        (kMaxClumpsPerForest,            4)
  257.  
  258.  
  259. #elif Is4Players
  260. //////////////////////////////////////////////////////////////////////
  261. // 4 PLAYERS...
  262. //////////////////////////////////////////////////////////////////////
  263.  
  264. //////////////////////////////////////////////////////////////////////
  265. // terrain definitions
  266. #define        (kMinIntElevation,                -10)
  267. #define        (kMaxIntElevation,                9)
  268. #define        (kElevationScale,                      1)
  269. #define        (kPercentLand,                    Between(0.4, 0.4))
  270. #define        (kWaterBorder,                    0)
  271. #define        (kRiverWidth,                    12)
  272. #define        (kCoastToDeepWaterPercentage                1.0)
  273. #define        (kHeightMapChaos,                    Between(10, 15))
  274.         
  275. #define        (kMinimumStartPositionToMapEdge        4)
  276. #define        (kOuterPushFromMapCenter            40)
  277. #define        (kInnerPushFromMapCenter             0)                                    
  278. //////////////////////////////////////////////////////////////////////
  279. // player definitions
  280. #define        (kMaxAngleBetweenTeamMembers,          55.0)
  281. #define        (kPlayerInnerRadius,            0.7)
  282. #define        (kPlayerOuterRadius,            0.99)
  283. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  284. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  285. #define        (kPlayerLandChaos,            0.8)
  286. #define        (kPlayerLandClumps,            1)
  287. #define        (kPlayerFlatChaos,            0.8)
  288. #define        (kPlayerFlatClumps,            1)
  289. #define        (kPlayerTreePercentage,            0.08)
  290.  
  291.  
  292. //////////////////////////////////////////////////////////////////////
  293. // inner neutral definitions
  294. #define        (kNeutralInnerRadius,            0.05)
  295. #define        (kNeutralOuterRadius,            0.54)
  296. #define        (kNeutralOptimalFactor,            0.7)
  297. #define        (kNumInnerNeutrals,            Between(5, 6))
  298. #define        (kInnerNeutralPercentLand,        0.37)
  299. #define        (kInnerNeutralPercentFlat,        Between(.7, .7))
  300. #define        (kInnerNeutralTreePercentage,          0.08)
  301. #define        (kInnerNeutralLandChaos,        0.8)
  302. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  303. #define        (kInnerNeutralFlatChaos,        0.8)
  304. #define        (kInnerNeutralFlatClumps,        1)
  305.  
  306.  
  307. //////////////////////////////////////////////////////////////////////
  308. // outer neutral definitions
  309. #define        (kNumOuterNeutrals,            Between(5, 6))
  310. #define        (kOuterNeutralPercentLand,        0.37)
  311. #define        (kOuterNeutralPercentFlat,        Between(.7, .7))
  312. #define        (kOuterNeutralTreePercentage,          0.08)
  313. #define        (kOuterNeutralLandChaos,        0.8)
  314. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  315. #define        (kOuterNeutralFlatChaos,        0.8)
  316. #define        (kOuterNeutralFlatClumps,        1)
  317.  
  318.  
  319. //////////////////////////////////////////////////////////////////////
  320. // resource definitions
  321. #define        (kMaxResourceElevation,            2)
  322. #define        (kResourceToEdgeDistance,        1)
  323. #define        (kResourceToWaterDistance,        2)
  324.  
  325. #define        (kAnimalPerPlayer,            0)
  326. #define        (kAnimalPerNeutral,            0)
  327.  
  328. #if (IsPaleoEpoch) 
  329.   #define  (kBerryPerPlayer,    2)
  330. #else
  331.   #define  (kBerryPerPlayer,    1)
  332. #endif 
  333. #define        (kBerryPerNeutral,            0)
  334.  
  335. #define        (kFishPerPlayer,                24)
  336. #define        (kFishPerNeutral,                40)
  337.  
  338. #define        (kGoldPerPlayer,                2)
  339. #define        (kGoldPerNeutral,                12)
  340.  
  341. #define        (kOilPerPlayer,                0)
  342. #define        (kOilPerNeutral,                0)
  343.  
  344. #define        (kSteelPerPlayer,                2)
  345. #define        (kSteelPerNeutral,            12)
  346.  
  347. #define        (kStonePerPlayer,                1)
  348. #define        (kStonePerNeutral,            6)
  349.  
  350. #define        (kTreePerPlayer,                1)
  351. #define        (kTreePerNeutral,                0)
  352.  
  353.  
  354. //////////////////////////////////////////////////////////////////////
  355. // forest definitions
  356. #define        (kForestFreeRadius,            8.0)
  357. #define        (kForestsPerPlayer,            4)
  358. #define        (kForestChaosLevel,            0.1)
  359. #define        (kMaxClumpsPerForest,            4)
  360.  
  361.  
  362. #elif Is5Players
  363. //////////////////////////////////////////////////////////////////////
  364. // 5 PLAYERS...
  365. //////////////////////////////////////////////////////////////////////
  366.  
  367. //////////////////////////////////////////////////////////////////////
  368. // terrain definitions
  369. #define        (kMinIntElevation,                -10)
  370. #define        (kMaxIntElevation,                9)
  371. #define        (kElevationScale,                      1)
  372. #define        (kPercentLand,                    Between(0.4, 0.4))
  373. #define        (kWaterBorder,                    0)
  374. #define        (kRiverWidth,                    12)
  375. #define        (kCoastToDeepWaterPercentage                1.0)
  376. #define        (kHeightMapChaos,                    Between(10, 15))
  377.         
  378. #define        (kMinimumStartPositionToMapEdge        4)
  379. #define        (kOuterPushFromMapCenter            40)
  380. #define        (kInnerPushFromMapCenter             0)
  381.  
  382. //////////////////////////////////////////////////////////////////////
  383. // player definitions
  384. #define        (kMaxAngleBetweenTeamMembers,          55.0)
  385. #define        (kPlayerInnerRadius,            0.7)
  386. #define        (kPlayerOuterRadius,            0.99)
  387. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  388. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  389. #define        (kPlayerLandChaos,            0.8)
  390. #define        (kPlayerLandClumps,            1)
  391. #define        (kPlayerFlatChaos,            0.8)
  392. #define        (kPlayerFlatClumps,            1)
  393. #define        (kPlayerTreePercentage,            0.08)
  394.  
  395.  
  396. //////////////////////////////////////////////////////////////////////
  397. // inner neutral definitions
  398. #define        (kNeutralInnerRadius,            0.05)
  399. #define        (kNeutralOuterRadius,            0.54)
  400. #define        (kNeutralOptimalFactor,            0.7)
  401. #define        (kNumInnerNeutrals,            Between(5, 6))
  402. #define        (kInnerNeutralPercentLand,        0.34)
  403. #define        (kInnerNeutralPercentFlat,        Between(.7, .7))
  404. #define        (kInnerNeutralTreePercentage,     0.08)
  405. #define        (kInnerNeutralLandChaos,        0.8)
  406. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  407. #define        (kInnerNeutralFlatChaos,        0.8)
  408. #define        (kInnerNeutralFlatClumps,        1)
  409.  
  410.  
  411. //////////////////////////////////////////////////////////////////////
  412. // outer neutral definitions
  413. #define        (kNumOuterNeutrals,            Between(5, 6))
  414. #define        (kOuterNeutralPercentLand,        0.34)
  415. #define        (kOuterNeutralPercentFlat,        Between(.7, .7))
  416. #define        (kOuterNeutralTreePercentage,          0.08)
  417. #define        (kOuterNeutralLandChaos,        0.8)
  418. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  419. #define        (kOuterNeutralFlatChaos,        0.8)
  420. #define        (kOuterNeutralFlatClumps,        1)
  421.  
  422.  
  423. //////////////////////////////////////////////////////////////////////
  424. // resource definitions
  425. #define        (kMaxResourceElevation,            2)
  426. #define        (kResourceToEdgeDistance,        1)
  427. #define        (kResourceToWaterDistance,        2)
  428.  
  429. #define        (kAnimalPerPlayer,            0)
  430. #define        (kAnimalPerNeutral,            0)
  431.  
  432. #if (IsPaleoEpoch) 
  433.   #define  (kBerryPerPlayer,    2)
  434. #else
  435.   #define  (kBerryPerPlayer,    1)
  436. #endif 
  437. #define        (kBerryPerNeutral,            0)
  438.  
  439. #define        (kFishPerPlayer,                21)
  440. #define        (kFishPerNeutral,                0)
  441.  
  442. #define        (kGoldPerPlayer,                2)
  443. #define        (kGoldPerNeutral,                13)
  444.  
  445. #define        (kOilPerPlayer,                0)
  446. #define        (kOilPerNeutral,                0)
  447.  
  448. #define        (kSteelPerPlayer,                2)
  449. #define        (kSteelPerNeutral,            13)
  450.  
  451. #define        (kStonePerPlayer,                1)
  452. #define        (kStonePerNeutral,            6)
  453.  
  454. #define        (kTreePerPlayer,                1)
  455. #define        (kTreePerNeutral,                0)
  456.  
  457.  
  458.  
  459. //////////////////////////////////////////////////////////////////////
  460. // forest definitions
  461. #define        (kForestFreeRadius,            8.0)
  462. #define        (kForestsPerPlayer,            4)
  463. #define        (kForestChaosLevel,            0.1)
  464. #define        (kMaxClumpsPerForest,            4)
  465.  
  466.  
  467. #elif Is6Players
  468. //////////////////////////////////////////////////////////////////////
  469. // 6 PLAYERS...
  470. //////////////////////////////////////////////////////////////////////
  471.  
  472. //////////////////////////////////////////////////////////////////////
  473. // terrain definitions
  474. #define        (kMinIntElevation,                -10)
  475. #define        (kMaxIntElevation,                9)
  476. #define        (kElevationScale,                      1)
  477. #define        (kPercentLand,                    Between(0.4, 0.4))
  478. #define        (kWaterBorder,                    0)
  479. #define        (kRiverWidth,                    12)
  480. #define        (kCoastToDeepWaterPercentage                1.0)
  481. #define        (kHeightMapChaos,                    Between(10, 15))
  482.         
  483. #define        (kMinimumStartPositionToMapEdge        4)
  484. #define        (kOuterPushFromMapCenter            40)
  485. #define        (kInnerPushFromMapCenter             0)
  486.  
  487. //////////////////////////////////////////////////////////////////////
  488. // player definitions
  489. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  490. #define        (kPlayerInnerRadius,            0.7)
  491. #define        (kPlayerOuterRadius,            0.99)
  492. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  493. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  494. #define        (kPlayerLandChaos,            0.8)
  495. #define        (kPlayerLandClumps,            1)
  496. #define        (kPlayerFlatChaos,            0.8)
  497. #define        (kPlayerFlatClumps,            1)
  498. #define        (kPlayerTreePercentage,            0.08)
  499.  
  500.  
  501. //////////////////////////////////////////////////////////////////////
  502. // inner neutral definitions
  503. #define        (kNeutralInnerRadius,            0.05)
  504. #define        (kNeutralOuterRadius,            0.54)
  505. #define        (kNeutralOptimalFactor,            0.7)
  506. #define        (kNumInnerNeutrals,            Between(6, 7))
  507. #define        (kInnerNeutralPercentLand,        0.42)
  508. #define        (kInnerNeutralPercentFlat,        Between(.7, .7))
  509. #define        (kInnerNeutralTreePercentage,          0.08)
  510. #define        (kInnerNeutralLandChaos,        0.8)
  511. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  512. #define        (kInnerNeutralFlatChaos,        0.8)
  513. #define        (kInnerNeutralFlatClumps,        1)
  514.  
  515.  
  516. //////////////////////////////////////////////////////////////////////
  517. // outer neutral definitions
  518. #define        (kNumOuterNeutrals,            Between(3, 4))
  519. #define        (kOuterNeutralPercentLand,        0.22)
  520. #define        (kOuterNeutralPercentFlat,        Between(.7, .7))
  521. #define        (kOuterNeutralTreePercentage,          0.08)
  522. #define        (kOuterNeutralLandChaos,        0.8)
  523. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  524. #define        (kOuterNeutralFlatChaos,        0.8)
  525. #define        (kOuterNeutralFlatClumps,        1)
  526.  
  527.  
  528. //////////////////////////////////////////////////////////////////////
  529. // resource definitions
  530. #define        (kMaxResourceElevation,            2)
  531. #define        (kResourceToEdgeDistance,        1)
  532. #define        (kResourceToWaterDistance,        2)
  533.  
  534. #define        (kAnimalPerPlayer,            0)
  535. #define        (kAnimalPerNeutral,            0)
  536.  
  537. #if (IsPaleoEpoch) 
  538.   #define  (kBerryPerPlayer,    2)
  539. #else
  540.   #define  (kBerryPerPlayer,    1)
  541. #endif 
  542. #define        (kBerryPerNeutral,            0)
  543.  
  544. #define        (kFishPerPlayer,                19)
  545. #define        (kFishPerNeutral,                0)
  546.  
  547. #define        (kGoldPerPlayer,                2)
  548. #define        (kGoldPerNeutral,                12)
  549.  
  550. #define        (kOilPerPlayer,                0)
  551. #define        (kOilPerNeutral,                0)
  552.  
  553. #define        (kSteelPerPlayer,                2)
  554. #define        (kSteelPerNeutral,            12)
  555.  
  556. #define        (kStonePerPlayer,                1)
  557. #define        (kStonePerNeutral,            6)
  558.  
  559. #define        (kTreePerPlayer,                1)
  560. #define        (kTreePerNeutral,                0)
  561.  
  562.  
  563. //////////////////////////////////////////////////////////////////////
  564. // forest definitions
  565. #define        (kForestFreeRadius,            8.0)
  566. #define        (kForestsPerPlayer,            4)
  567. #define        (kForestChaosLevel,            0.1)
  568. #define        (kMaxClumpsPerForest,            4)
  569.  
  570.  
  571. #elif Is7Players
  572. //////////////////////////////////////////////////////////////////////
  573. // 7 PLAYERS...
  574. //////////////////////////////////////////////////////////////////////
  575.  
  576. //////////////////////////////////////////////////////////////////////
  577. // terrain definitions
  578. #define        (kMinIntElevation,                -10)
  579. #define        (kMaxIntElevation,                9)
  580. #define        (kElevationScale,                      1)
  581. #define        (kPercentLand,                    Between(0.4, 0.4))
  582. #define        (kWaterBorder,                    0)
  583. #define        (kRiverWidth,                    12)
  584. #define        (kCoastToDeepWaterPercentage                1.0)
  585. #define        (kHeightMapChaos,                    Between(10, 15))
  586.         
  587. #define        (kMinimumStartPositionToMapEdge        4)
  588. #define        (kOuterPushFromMapCenter            40)
  589. #define        (kInnerPushFromMapCenter             0)
  590.                                             
  591.  
  592. //////////////////////////////////////////////////////////////////////
  593. // player definitions
  594. #define        (kMaxAngleBetweenTeamMembers,          40.0)
  595. #define        (kPlayerInnerRadius,            0.7)
  596. #define        (kPlayerOuterRadius,            0.99)
  597. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  598. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  599. #define        (kPlayerLandChaos,            0.8)
  600. #define        (kPlayerLandClumps,            1)
  601. #define        (kPlayerFlatChaos,            0.8)
  602. #define        (kPlayerFlatClumps,            1)
  603. #define        (kPlayerTreePercentage,            0.08)
  604.  
  605. //////////////////////////////////////////////////////////////////////
  606. // inner neutral definitions
  607. #define        (kNeutralInnerRadius,            0.05)
  608. #define        (kNeutralOuterRadius,            0.55)
  609. #define        (kNeutralOptimalFactor,            0.7)
  610. #define        (kNumInnerNeutrals,            Between(6, 7))
  611. #define        (kInnerNeutralPercentLand,        0.42)
  612. #define        (kInnerNeutralPercentFlat,        Between(.7, .7))
  613. #define        (kInnerNeutralTreePercentage,          0.08)
  614. #define        (kInnerNeutralLandChaos,        0.8)
  615. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  616. #define        (kInnerNeutralFlatChaos,        0.8)
  617. #define        (kInnerNeutralFlatClumps,        1)
  618.  
  619.  
  620. //////////////////////////////////////////////////////////////////////
  621. // outer neutral definitions
  622. #define        (kNumOuterNeutrals,            Between(2, 3))
  623. #define        (kOuterNeutralPercentLand,        0.16)
  624. #define        (kOuterNeutralPercentFlat,        Between(.7, .7))
  625. #define        (kOuterNeutralTreePercentage,          0.08)
  626. #define        (kOuterNeutralLandChaos,        0.8)
  627. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  628. #define        (kOuterNeutralFlatChaos,        0.8)
  629. #define        (kOuterNeutralFlatClumps,        1)
  630.  
  631.  
  632. //////////////////////////////////////////////////////////////////////
  633. // resource definitions
  634. #define        (kMaxResourceElevation,            2)
  635. #define        (kResourceToEdgeDistance,        1)
  636. #define        (kResourceToWaterDistance,        2)
  637.  
  638. #define        (kAnimalPerPlayer,            0)
  639. #define        (kAnimalPerNeutral,            0)
  640.  
  641. #if (IsPaleoEpoch) 
  642.   #define  (kBerryPerPlayer,    2)
  643. #else
  644.   #define  (kBerryPerPlayer,    1)
  645. #endif 
  646. #define        (kBerryPerNeutral,            0)
  647.  
  648. #define        (kFishPerPlayer,                15)
  649. #define        (kFishPerNeutral,                0)
  650.  
  651. #define        (kGoldPerPlayer,                2)
  652. #define        (kGoldPerNeutral,                14)
  653.  
  654. #define        (kOilPerPlayer,                0)
  655. #define        (kOilPerNeutral,                0)
  656.  
  657. #define        (kSteelPerPlayer,                2)
  658. #define        (kSteelPerNeutral,            14)
  659.  
  660. #define        (kStonePerPlayer,                1)
  661. #define        (kStonePerNeutral,            7)
  662.  
  663. #define        (kTreePerPlayer,                1)
  664. #define        (kTreePerNeutral,                0)
  665.  
  666.  
  667. //////////////////////////////////////////////////////////////////////
  668. // forest definitions
  669. #define        (kForestFreeRadius,            8.0)
  670. #define        (kForestsPerPlayer,            4)
  671. #define        (kForestChaosLevel,            0.1)
  672. #define        (kMaxClumpsPerForest,            4)
  673.  
  674.  
  675. #elif Is8Players
  676. //////////////////////////////////////////////////////////////////////
  677. // 8 PLAYERS...
  678. //////////////////////////////////////////////////////////////////////
  679.  
  680. //////////////////////////////////////////////////////////////////////
  681. // terrain definitions
  682. #define        (kMinIntElevation,                -10)
  683. #define        (kMaxIntElevation,                9)
  684. #define        (kElevationScale,                      1)
  685. #define        (kPercentLand,                    Between(0.4, 0.4))
  686. #define        (kWaterBorder,                    0)
  687. #define        (kRiverWidth,                    12)
  688. #define        (kCoastToDeepWaterPercentage                1.0)
  689. #define        (kHeightMapChaos,                    Between(10, 15))
  690.         
  691. #define        (kMinimumStartPositionToMapEdge        4)
  692. #define        (kOuterPushFromMapCenter            40)
  693. #define        (kInnerPushFromMapCenter             0)
  694.  
  695. //////////////////////////////////////////////////////////////////////
  696. // player definitions
  697. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  698. #define        (kPlayerInnerRadius,            0.7)
  699. #define        (kPlayerOuterRadius,            0.99)
  700. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  701. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  702. #define        (kPlayerLandChaos,            0.8)
  703. #define        (kPlayerLandClumps,            1)
  704. #define        (kPlayerFlatChaos,            0.8)
  705. #define        (kPlayerFlatClumps,            1)
  706. #define        (kPlayerTreePercentage,            0.08)
  707.  
  708.  
  709. //////////////////////////////////////////////////////////////////////
  710. // inner neutral definitions
  711. #define        (kNeutralInnerRadius,            0.1)
  712. #define        (kNeutralOuterRadius,            0.54)
  713. #define        (kNeutralOptimalFactor,            0.7)
  714. #define        (kNumInnerNeutrals,            Between(7, 8))
  715. #define        (kInnerNeutralPercentLand,        0.5)
  716. #define        (kInnerNeutralPercentFlat,        Between(.7, .7))
  717. #define        (kInnerNeutralTreePercentage,          0.08)
  718. #define        (kInnerNeutralLandChaos,        0.8)
  719. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  720. #define        (kInnerNeutralFlatChaos,        0.8)
  721. #define        (kInnerNeutralFlatClumps,        1)
  722.  
  723.  
  724. //////////////////////////////////////////////////////////////////////
  725. // outer neutral definitions
  726. #define        (kNumOuterNeutrals,            Between(0, 0))
  727. #define        (kOuterNeutralPercentLand,        0.35)
  728. #define        (kOuterNeutralPercentFlat,        Between(.7, .7))
  729. #define        (kOuterNeutralTreePercentage,          0.08)
  730. #define        (kOuterNeutralLandChaos,        0.8)
  731. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  732. #define        (kOuterNeutralFlatChaos,        0.8)
  733. #define        (kOuterNeutralFlatClumps,        1)
  734.  
  735.  
  736. //////////////////////////////////////////////////////////////////////
  737. // resource definitions
  738. #define        (kMaxResourceElevation,            2)
  739. #define        (kResourceToEdgeDistance,        1)
  740. #define        (kResourceToWaterDistance,        2)
  741.  
  742. #define        (kAnimalPerPlayer,            0)
  743. #define        (kAnimalPerNeutral,            0)
  744.  
  745. #if (IsPaleoEpoch) 
  746.   #define  (kBerryPerPlayer,    2)
  747. #else
  748.   #define  (kBerryPerPlayer,    1)
  749. #endif 
  750. #define        (kBerryPerNeutral,            0)
  751.  
  752. #define        (kFishPerPlayer,                15)
  753. #define        (kFishPerNeutral,                0)
  754.  
  755. #define        (kGoldPerPlayer,                2)
  756. #define        (kGoldPerNeutral,                16)
  757.  
  758. #define        (kOilPerPlayer,                0)
  759. #define        (kOilPerNeutral,                0)
  760.  
  761. #define        (kSteelPerPlayer,                2)
  762. #define        (kSteelPerNeutral,            16)
  763.  
  764. #define        (kStonePerPlayer,                1)
  765. #define        (kStonePerNeutral,            8)
  766.  
  767. #define        (kTreePerPlayer,                1)
  768. #define        (kTreePerNeutral,                0)
  769.  
  770. //////////////////////////////////////////////////////////////////////
  771. // forest definitions
  772. #define        (kForestFreeRadius,            8.0)
  773. #define        (kForestsPerPlayer,            4)
  774. #define        (kForestChaosLevel,            0.1)
  775. #define        (kMaxClumpsPerForest,            4)
  776.  
  777.  
  778. #elif Is9Players
  779. //////////////////////////////////////////////////////////////////////
  780. // 9 PLAYERS...
  781. //////////////////////////////////////////////////////////////////////
  782.  
  783. //////////////////////////////////////////////////////////////////////
  784. // terrain definitions
  785. #define        (kMinIntElevation,                -10)
  786. #define        (kMaxIntElevation,                12)
  787. #define        (kElevationScale,                      1)
  788. #define        (kPercentLand,                    Between(0.45, 0.45))
  789. #define        (kWaterBorder,                    0)
  790. #define        (kRiverWidth,                    11)
  791. #define        (kCoastToDeepWaterPercentage                1.0)
  792. #define        (kHeightMapChaos,                    Between(10, 15))
  793.         
  794. #define        (kMinimumStartPositionToMapEdge        4)
  795. #define        (kOuterPushFromMapCenter            34)
  796. #define        (kInnerPushFromMapCenter             0)
  797.  
  798. //////////////////////////////////////////////////////////////////////
  799. // player definitions
  800. #define        (kMaxAngleBetweenTeamMembers,        45.0)
  801. #define        (kPlayerInnerRadius,            0.5)
  802. #define        (kPlayerOuterRadius,            0.99)
  803. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  804. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  805. #define        (kPlayerLandChaos,            0.8)
  806. #define        (kPlayerLandClumps,            1)
  807. #define        (kPlayerFlatChaos,            0.8)
  808. #define        (kPlayerFlatClumps,            2)
  809. #define        (kPlayerTreePercentage,            0.035)
  810.  
  811.  
  812. //////////////////////////////////////////////////////////////////////
  813. // inner neutral definitions
  814. #define        (kNeutralInnerRadius,            0.1)
  815. #define        (kNeutralOuterRadius,            0.4)
  816. #define        (kNeutralOptimalFactor,            0.7)
  817. #define        (kNumInnerNeutrals,            Between(3, 3))
  818. #define        (kInnerNeutralPercentLand,        0.3)
  819. #define        (kInnerNeutralPercentFlat,        Between(.4, .7))
  820. #define        (kInnerNeutralTreePercentage,          0.035)
  821. #define        (kInnerNeutralLandChaos,        0.8)
  822. #define        (kInnerNeutralLandClumps,        Between(1, 2))
  823. #define        (kInnerNeutralFlatChaos,        0.8)
  824. #define        (kInnerNeutralFlatClumps,        2)
  825.  
  826.  
  827. //////////////////////////////////////////////////////////////////////
  828. // outer neutral definitions
  829. #define        (kNumOuterNeutrals,            Between(0, 0))
  830. #define        (kOuterNeutralPercentLand,        0.35)
  831. #define        (kOuterNeutralPercentFlat,        Between(.4, .7))
  832. #define        (kOuterNeutralTreePercentage,          0.035)
  833. #define        (kOuterNeutralLandChaos,        0.8)
  834. #define        (kOuterNeutralLandClumps,        Between(1, 2))
  835. #define        (kOuterNeutralFlatChaos,        0.8)
  836. #define        (kOuterNeutralFlatClumps,        2)
  837.  
  838.  
  839. //////////////////////////////////////////////////////////////////////
  840. // resource definitions
  841. #define        (kMaxResourceElevation,            2)
  842. #define        (kResourceToEdgeDistance,        2)
  843. #define        (kResourceToWaterDistance,        2)
  844.  
  845. #define        (kAnimalPerPlayer,            0)
  846. #define        (kAnimalPerNeutral,            0)
  847.  
  848. #define        (kBerryPerPlayer,                0)
  849. #define        (kBerryPerNeutral,            0)
  850.  
  851. #define        (kFishPerPlayer,                13)
  852. #define        (kFishPerNeutral,                0)
  853.  
  854. #define        (kGoldPerPlayer,                3)
  855. #define        (kGoldPerNeutral,                5)
  856.  
  857. #define        (kOilPerPlayer,                0)
  858. #define        (kOilPerNeutral,                0)
  859.  
  860. #define        (kSteelPerPlayer,                3)
  861. #define        (kSteelPerNeutral,            5)
  862.  
  863. #define        (kStonePerPlayer,                1)
  864. #define        (kStonePerNeutral,            5)
  865.  
  866. #define        (kTreePerPlayer,                0)
  867. #define        (kTreePerNeutral,                0)
  868.  
  869. //////////////////////////////////////////////////////////////////////
  870. // forest definitions
  871. #define        (kForestFreeRadius,            7.0)
  872. #define        (kForestsPerPlayer,            4)
  873. #define        (kForestChaosLevel,            0.1)
  874. #define        (kMaxClumpsPerForest,            4)
  875.  
  876.  
  877. #elif Is10Players
  878. //////////////////////////////////////////////////////////////////////
  879. // 10 PLAYERS...
  880. //////////////////////////////////////////////////////////////////////
  881.  
  882. //////////////////////////////////////////////////////////////////////
  883. // terrain definitions
  884. #define        (kMinIntElevation,                -10)
  885. #define        (kMaxIntElevation,                12)
  886. #define        (kElevationScale,                      1)
  887. #define        (kPercentLand,                    Between(0.45, 0.45))
  888. #define        (kWaterBorder,                    0)
  889. #define        (kRiverWidth,                    10)
  890. #define        (kCoastToDeepWaterPercentage                1.0)
  891. #define        (kHeightMapChaos,                    Between(12, 25))
  892.         
  893. #define        (kMinimumStartPositionToMapEdge        4)
  894. #define        (kOuterPushFromMapCenter            32)
  895. #define        (kInnerPushFromMapCenter             0)
  896.  
  897. //////////////////////////////////////////////////////////////////////
  898. // player definitions
  899. #define        (kMaxAngleBetweenTeamMembers,        45.0)
  900. #define        (kPlayerInnerRadius,            0.5)
  901. #define        (kPlayerOuterRadius,            0.99)
  902. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  903. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  904. #define        (kPlayerLandChaos,            0.8)
  905. #define        (kPlayerLandClumps,            1)
  906. #define        (kPlayerFlatChaos,            0.8)
  907. #define        (kPlayerFlatClumps,            2)
  908. #define        (kPlayerTreePercentage,            0.035)
  909.  
  910.  
  911. //////////////////////////////////////////////////////////////////////
  912. // inner neutral definitions
  913. #define        (kNeutralInnerRadius,            0.1)
  914. #define        (kNeutralOuterRadius,            0.3)
  915. #define        (kNeutralOptimalFactor,            0.7)
  916. #define        (kNumInnerNeutrals,            Between(2, 2))
  917. #define        (kInnerNeutralPercentLand,        0.20)
  918. #define        (kInnerNeutralPercentFlat,        Between(.4, .7))
  919. #define        (kInnerNeutralTreePercentage,          0.035)
  920. #define        (kInnerNeutralLandChaos,        0.8)
  921. #define        (kInnerNeutralLandClumps,        Between(1, 2))
  922. #define        (kInnerNeutralFlatChaos,        0.8)
  923. #define        (kInnerNeutralFlatClumps,        2)
  924.  
  925.  
  926. //////////////////////////////////////////////////////////////////////
  927. // outer neutral definitions
  928. #define        (kNumOuterNeutrals,            Between(0, 0))
  929. #define        (kOuterNeutralPercentLand,        0.35)
  930. #define        (kOuterNeutralPercentFlat,        Between(.4, .7))
  931. #define        (kOuterNeutralTreePercentage,          0.035)
  932. #define        (kOuterNeutralLandChaos,        0.8)
  933. #define        (kOuterNeutralLandClumps,        Between(1, 2))
  934. #define        (kOuterNeutralFlatChaos,        0.8)
  935. #define        (kOuterNeutralFlatClumps,        2)
  936.  
  937.  
  938. //////////////////////////////////////////////////////////////////////
  939. // resource definitions
  940. #define        (kMaxResourceElevation,            2)
  941. #define        (kResourceToEdgeDistance,        2)
  942. #define        (kResourceToWaterDistance,        2)
  943.  
  944. #define        (kAnimalPerPlayer,            0)
  945. #define        (kAnimalPerNeutral,            0)
  946.  
  947. #define        (kBerryPerPlayer,                0)
  948. #define        (kBerryPerNeutral,            0)
  949.  
  950. #define        (kFishPerPlayer,                13)
  951. #define        (kFishPerNeutral,                0)
  952.  
  953. #define        (kGoldPerPlayer,                3)
  954. #define        (kGoldPerNeutral,                4)
  955.  
  956. #define        (kOilPerPlayer,                0)
  957. #define        (kOilPerNeutral,                0)
  958.  
  959. #define        (kSteelPerPlayer,                3)
  960. #define        (kSteelPerNeutral,            4)
  961.  
  962. #define        (kStonePerPlayer,                1)
  963. #define        (kStonePerNeutral,            4)
  964.  
  965. #define        (kTreePerPlayer,                0)
  966. #define        (kTreePerNeutral,                0)
  967.  
  968. //////////////////////////////////////////////////////////////////////
  969. // forest definitions
  970. #define        (kForestFreeRadius,            7.0)
  971. #define        (kForestsPerPlayer,            4)
  972. #define        (kForestChaosLevel,            0.1)
  973. #define        (kMaxClumpsPerForest,            4)
  974.  
  975.  
  976. #elif Is11Players
  977. //////////////////////////////////////////////////////////////////////
  978. // 11 PLAYERS...
  979. //////////////////////////////////////////////////////////////////////
  980.  
  981. //////////////////////////////////////////////////////////////////////
  982. // terrain definitions
  983. #define        (kMinIntElevation,                -10)
  984. #define        (kMaxIntElevation,                12)
  985. #define        (kElevationScale,                      1)
  986. #define        (kPercentLand,                    Between(0.45, 0.45))
  987. #define        (kWaterBorder,                    0)
  988. #define        (kRiverWidth,                    9)
  989. #define        (kCoastToDeepWaterPercentage                1.0)
  990. #define        (kHeightMapChaos,                    Between(12, 25))
  991.         
  992. #define        (kMinimumStartPositionToMapEdge        4)
  993. #define        (kOuterPushFromMapCenter            30)
  994. #define        (kInnerPushFromMapCenter             0)
  995.  
  996. //////////////////////////////////////////////////////////////////////
  997. // player definitions
  998. #define        (kMaxAngleBetweenTeamMembers,        45.0)
  999. #define        (kPlayerInnerRadius,            0.5)
  1000. #define        (kPlayerOuterRadius,            0.99)
  1001. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1002. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  1003. #define        (kPlayerLandChaos,            0.8)
  1004. #define        (kPlayerLandClumps,            1)
  1005. #define        (kPlayerFlatChaos,            0.8)
  1006. #define        (kPlayerFlatClumps,            2)
  1007. #define        (kPlayerTreePercentage,            0.035)
  1008.  
  1009.  
  1010. //////////////////////////////////////////////////////////////////////
  1011. // inner neutral definitions
  1012. #define        (kNeutralInnerRadius,            0.1)
  1013. #define        (kNeutralOuterRadius,            0.3)
  1014. #define        (kNeutralOptimalFactor,            0.7)
  1015. #define        (kNumInnerNeutrals,            Between(1, 1))
  1016. #define        (kInnerNeutralPercentLand,        0.1)
  1017. #define        (kInnerNeutralPercentFlat,        Between(.4, .7))
  1018. #define        (kInnerNeutralTreePercentage,          0.035)
  1019. #define        (kInnerNeutralLandChaos,        0.8)
  1020. #define        (kInnerNeutralLandClumps,        Between(1, 2))
  1021. #define        (kInnerNeutralFlatChaos,        0.8)
  1022. #define        (kInnerNeutralFlatClumps,        2)
  1023.  
  1024.  
  1025. //////////////////////////////////////////////////////////////////////
  1026. // outer neutral definitions
  1027. #define        (kNumOuterNeutrals,            Between(0, 0))
  1028. #define        (kOuterNeutralPercentLand,        0.35)
  1029. #define        (kOuterNeutralPercentFlat,        Between(.4, .7))
  1030. #define        (kOuterNeutralTreePercentage,          0.035)
  1031. #define        (kOuterNeutralLandChaos,        0.8)
  1032. #define        (kOuterNeutralLandClumps,        Between(1, 2))
  1033. #define        (kOuterNeutralFlatChaos,        0.8)
  1034. #define        (kOuterNeutralFlatClumps,        2)
  1035.  
  1036.  
  1037. //////////////////////////////////////////////////////////////////////
  1038. // resource definitions
  1039. #define        (kMaxResourceElevation,            2)
  1040. #define        (kResourceToEdgeDistance,        2)
  1041. #define        (kResourceToWaterDistance,        2)
  1042.  
  1043. #define        (kAnimalPerPlayer,            0)
  1044. #define        (kAnimalPerNeutral,            0)
  1045.  
  1046. #define        (kBerryPerPlayer,                0)
  1047. #define        (kBerryPerNeutral,            0)
  1048.  
  1049. #define        (kFishPerPlayer,                10)
  1050. #define        (kFishPerNeutral,                0)
  1051.  
  1052. #define        (kGoldPerPlayer,                3)
  1053. #define        (kGoldPerNeutral,                2)
  1054.  
  1055. #define        (kOilPerPlayer,                0)
  1056. #define        (kOilPerNeutral,                0)
  1057.  
  1058. #define        (kSteelPerPlayer,                3)
  1059. #define        (kSteelPerNeutral,            2)
  1060.  
  1061. #define        (kStonePerPlayer,                1)
  1062. #define        (kStonePerNeutral,            2)
  1063.  
  1064. #define        (kTreePerPlayer,                0)
  1065. #define        (kTreePerNeutral,                0)
  1066.  
  1067. //////////////////////////////////////////////////////////////////////
  1068. // forest definitions
  1069. #define        (kForestFreeRadius,            7.0)
  1070. #define        (kForestsPerPlayer,            4)
  1071. #define        (kForestChaosLevel,            0.1)
  1072. #define        (kMaxClumpsPerForest,            4)
  1073.  
  1074.  
  1075. #elif Is12Players
  1076. //////////////////////////////////////////////////////////////////////
  1077. // 12 PLAYERS...
  1078. //////////////////////////////////////////////////////////////////////
  1079.  
  1080. //////////////////////////////////////////////////////////////////////
  1081. // terrain definitions
  1082. #define        (kMinIntElevation,                -10)
  1083. #define        (kMaxIntElevation,                12)
  1084. #define        (kElevationScale,                      1)
  1085. #define        (kPercentLand,                    Between(0.45, 0.45))
  1086. #define        (kWaterBorder,                    0)
  1087. #define        (kRiverWidth,                    12)
  1088. #define        (kCoastToDeepWaterPercentage                1.0)
  1089. #define        (kHeightMapChaos,                    Between(12, 25))
  1090.         
  1091. #define        (kMinimumStartPositionToMapEdge        4)
  1092. #define        (kOuterPushFromMapCenter            28)
  1093. #define        (kInnerPushFromMapCenter             0)
  1094.  
  1095. //////////////////////////////////////////////////////////////////////
  1096. // player definitions
  1097. #define        (kMaxAngleBetweenTeamMembers,        45.0)
  1098. #define        (kPlayerInnerRadius,            0.2)
  1099. #define        (kPlayerOuterRadius,            0.99)
  1100. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1101. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  1102. #define        (kPlayerLandChaos,            0.8)
  1103. #define        (kPlayerLandClumps,            1)
  1104. #define        (kPlayerFlatChaos,            0.8)
  1105. #define        (kPlayerFlatClumps,            2)
  1106. #define        (kPlayerTreePercentage,            0.035)
  1107.  
  1108.  
  1109. //////////////////////////////////////////////////////////////////////
  1110. // inner neutral definitions
  1111. #define        (kNeutralInnerRadius,            0.1)
  1112. #define        (kNeutralOuterRadius,            0.55)
  1113. #define        (kNeutralOptimalFactor,            0.7)
  1114. #define        (kNumInnerNeutrals,            Between(0, 0))
  1115. #define        (kInnerNeutralPercentLand,        0.32)
  1116. #define        (kInnerNeutralPercentFlat,        Between(.4, .7))
  1117. #define        (kInnerNeutralTreePercentage,          0.035)
  1118. #define        (kInnerNeutralLandChaos,        0.8)
  1119. #define        (kInnerNeutralLandClumps,        Between(1, 2))
  1120. #define        (kInnerNeutralFlatChaos,        0.8)
  1121. #define        (kInnerNeutralFlatClumps,        2)
  1122.  
  1123.  
  1124. //////////////////////////////////////////////////////////////////////
  1125. // outer neutral definitions
  1126. #define        (kNumOuterNeutrals,            Between(0, 0))
  1127. #define        (kOuterNeutralPercentLand,        0.35)
  1128. #define        (kOuterNeutralPercentFlat,        Between(.4, .7))
  1129. #define        (kOuterNeutralTreePercentage,          0.035)
  1130. #define        (kOuterNeutralLandChaos,        0.8)
  1131. #define        (kOuterNeutralLandClumps,        Between(1, 2))
  1132. #define        (kOuterNeutralFlatChaos,        0.8)
  1133. #define        (kOuterNeutralFlatClumps,        2)
  1134.  
  1135.  
  1136. //////////////////////////////////////////////////////////////////////
  1137. // resource definitions
  1138. #define        (kMaxResourceElevation,            2)
  1139. #define        (kResourceToEdgeDistance,        2)
  1140. #define        (kResourceToWaterDistance,        2)
  1141.  
  1142. #define        (kAnimalPerPlayer,            0)
  1143. #define        (kAnimalPerNeutral,            0)
  1144.  
  1145. #define        (kBerryPerPlayer,                0)
  1146. #define        (kBerryPerNeutral,            0)
  1147.  
  1148. #define        (kFishPerPlayer,                10)
  1149. #define        (kFishPerNeutral,                0)
  1150.  
  1151. #define        (kGoldPerPlayer,                3)
  1152. #define        (kGoldPerNeutral,                0)
  1153.  
  1154. #define        (kOilPerPlayer,                0)
  1155. #define        (kOilPerNeutral,                0)
  1156.  
  1157. #define        (kSteelPerPlayer,                3)
  1158. #define        (kSteelPerNeutral,            0)
  1159.  
  1160. #define        (kStonePerPlayer,                1)
  1161. #define        (kStonePerNeutral,            0)
  1162.  
  1163. #define        (kTreePerPlayer,                0)
  1164. #define        (kTreePerNeutral,                0)
  1165.  
  1166. //////////////////////////////////////////////////////////////////////
  1167. // forest definitions
  1168. #define        (kForestFreeRadius,            7.0)
  1169. #define        (kForestsPerPlayer,            4)
  1170. #define        (kForestChaosLevel,            0.1)
  1171. #define        (kMaxClumpsPerForest,            4)
  1172.  
  1173.  
  1174. #elif Is13Players
  1175. //////////////////////////////////////////////////////////////////////
  1176. // 13 PLAYERS...
  1177. //////////////////////////////////////////////////////////////////////
  1178.  
  1179. //////////////////////////////////////////////////////////////////////
  1180. // terrain definitions
  1181. #define        (kMinIntElevation,                -10)
  1182. #define        (kMaxIntElevation,                12)
  1183. #define        (kElevationScale,                      1)
  1184. #define        (kPercentLand,                    Between(0.45, 0.45))
  1185. #define        (kWaterBorder,                    0)
  1186. #define        (kRiverWidth,                    12)
  1187. #define        (kCoastToDeepWaterPercentage                1.0)
  1188. #define        (kHeightMapChaos,                    Between(12, 25))
  1189.         
  1190. #define        (kMinimumStartPositionToMapEdge        4)
  1191. #define        (kOuterPushFromMapCenter            26)
  1192. #define        (kInnerPushFromMapCenter             0)
  1193.  
  1194. //////////////////////////////////////////////////////////////////////
  1195. // player definitions
  1196. #define        (kMaxAngleBetweenTeamMembers,        45.0)
  1197. #define        (kPlayerInnerRadius,            0.1)
  1198. #define        (kPlayerOuterRadius,            0.99)
  1199. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1200. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  1201. #define        (kPlayerLandChaos,            0.8)
  1202. #define        (kPlayerLandClumps,            1)
  1203. #define        (kPlayerFlatChaos,            0.8)
  1204. #define        (kPlayerFlatClumps,            2)
  1205. #define        (kPlayerTreePercentage,            0.035)
  1206.  
  1207.  
  1208. //////////////////////////////////////////////////////////////////////
  1209. // inner neutral definitions
  1210. #define        (kNeutralInnerRadius,            0.1)
  1211. #define        (kNeutralOuterRadius,            0.55)
  1212. #define        (kNeutralOptimalFactor,            0.7)
  1213. #define        (kNumInnerNeutrals,            Between(0, 0))
  1214. #define        (kInnerNeutralPercentLand,        0.32)
  1215. #define        (kInnerNeutralPercentFlat,        Between(.4, .7))
  1216. #define        (kInnerNeutralTreePercentage,          0.035)
  1217. #define        (kInnerNeutralLandChaos,        0.8)
  1218. #define        (kInnerNeutralLandClumps,        Between(1, 2))
  1219. #define        (kInnerNeutralFlatChaos,        0.8)
  1220. #define        (kInnerNeutralFlatClumps,        2)
  1221.  
  1222.  
  1223. //////////////////////////////////////////////////////////////////////
  1224. // outer neutral definitions
  1225. #define        (kNumOuterNeutrals,            Between(0, 0))
  1226. #define        (kOuterNeutralPercentLand,        0.35)
  1227. #define        (kOuterNeutralPercentFlat,        Between(.4, .7))
  1228. #define        (kOuterNeutralTreePercentage,          0.035)
  1229. #define        (kOuterNeutralLandChaos,        0.8)
  1230. #define        (kOuterNeutralLandClumps,        Between(1, 2))
  1231. #define        (kOuterNeutralFlatChaos,        0.8)
  1232. #define        (kOuterNeutralFlatClumps,        2)
  1233.  
  1234.  
  1235. //////////////////////////////////////////////////////////////////////
  1236. // resource definitions
  1237. #define        (kMaxResourceElevation,            2)
  1238. #define        (kResourceToEdgeDistance,        2)
  1239. #define        (kResourceToWaterDistance,        2)
  1240.  
  1241. #define        (kAnimalPerPlayer,            0)
  1242. #define        (kAnimalPerNeutral,            0)
  1243.  
  1244. #define        (kBerryPerPlayer,                0)
  1245. #define        (kBerryPerNeutral,            0)
  1246.  
  1247. #define        (kFishPerPlayer,                9)
  1248. #define        (kFishPerNeutral,                0)
  1249.  
  1250. #define        (kGoldPerPlayer,                3)
  1251. #define        (kGoldPerNeutral,                0)
  1252.  
  1253. #define        (kOilPerPlayer,                0)
  1254. #define        (kOilPerNeutral,                0)
  1255.  
  1256. #define        (kSteelPerPlayer,                3)
  1257. #define        (kSteelPerNeutral,            0)
  1258.  
  1259. #define        (kStonePerPlayer,                1)
  1260. #define        (kStonePerNeutral,            0)
  1261.  
  1262. #define        (kTreePerPlayer,                0)
  1263. #define        (kTreePerNeutral,                0)
  1264.  
  1265. //////////////////////////////////////////////////////////////////////
  1266. // forest definitions
  1267. #define        (kForestFreeRadius,            7.0)
  1268. #define        (kForestsPerPlayer,            4)
  1269. #define        (kForestChaosLevel,            0.1)
  1270. #define        (kMaxClumpsPerForest,            4)
  1271.  
  1272.  
  1273. #elif Is14Players
  1274. //////////////////////////////////////////////////////////////////////
  1275. // 14 PLAYERS...
  1276. //////////////////////////////////////////////////////////////////////
  1277.  
  1278. //////////////////////////////////////////////////////////////////////
  1279. // terrain definitions
  1280. #define        (kMinIntElevation,                -10)
  1281. #define        (kMaxIntElevation,                12)
  1282. #define        (kElevationScale,                      1)
  1283. #define        (kPercentLand,                    Between(0.45, 0.45))
  1284. #define        (kWaterBorder,                    0)
  1285. #define        (kRiverWidth,                    12)
  1286. #define        (kCoastToDeepWaterPercentage                1.0)
  1287. #define        (kHeightMapChaos,                    Between(12, 25))
  1288.         
  1289. #define        (kMinimumStartPositionToMapEdge        4)
  1290. #define        (kOuterPushFromMapCenter            24)
  1291. #define        (kInnerPushFromMapCenter             0)
  1292.  
  1293. //////////////////////////////////////////////////////////////////////
  1294. // player definitions
  1295. #define        (kMaxAngleBetweenTeamMembers,        45.0)
  1296. #define        (kPlayerInnerRadius,            0.1)
  1297. #define        (kPlayerOuterRadius,            0.99)
  1298. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1299. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  1300. #define        (kPlayerLandChaos,            0.8)
  1301. #define        (kPlayerLandClumps,            1)
  1302. #define        (kPlayerFlatChaos,            0.8)
  1303. #define        (kPlayerFlatClumps,            2)
  1304. #define        (kPlayerTreePercentage,            0.035)
  1305.  
  1306.  
  1307. //////////////////////////////////////////////////////////////////////
  1308. // inner neutral definitions
  1309. #define        (kNeutralInnerRadius,            0.1)
  1310. #define        (kNeutralOuterRadius,            0.55)
  1311. #define        (kNeutralOptimalFactor,            0.7)
  1312. #define        (kNumInnerNeutrals,            Between(0, 0))
  1313. #define        (kInnerNeutralPercentLand,        0.32)
  1314. #define        (kInnerNeutralPercentFlat,        Between(.4, .7))
  1315. #define        (kInnerNeutralTreePercentage,          0.035)
  1316. #define        (kInnerNeutralLandChaos,        0.8)
  1317. #define        (kInnerNeutralLandClumps,        Between(1, 2))
  1318. #define        (kInnerNeutralFlatChaos,        0.8)
  1319. #define        (kInnerNeutralFlatClumps,        2)
  1320.  
  1321.  
  1322. //////////////////////////////////////////////////////////////////////
  1323. // outer neutral definitions
  1324. #define        (kNumOuterNeutrals,            Between(0, 0))
  1325. #define        (kOuterNeutralPercentLand,        0.35)
  1326. #define        (kOuterNeutralPercentFlat,        Between(.4, .7))
  1327. #define        (kOuterNeutralTreePercentage,          0.035)
  1328. #define        (kOuterNeutralLandChaos,        0.8)
  1329. #define        (kOuterNeutralLandClumps,        Between(1, 2))
  1330. #define        (kOuterNeutralFlatChaos,        0.8)
  1331. #define        (kOuterNeutralFlatClumps,        2)
  1332.  
  1333.  
  1334. //////////////////////////////////////////////////////////////////////
  1335. // resource definitions
  1336. #define        (kMaxResourceElevation,            2)
  1337. #define        (kResourceToEdgeDistance,        2)
  1338. #define        (kResourceToWaterDistance,        2)
  1339.  
  1340. #define        (kAnimalPerPlayer,            0)
  1341. #define        (kAnimalPerNeutral,            0)
  1342.  
  1343. #define        (kBerryPerPlayer,                0)
  1344. #define        (kBerryPerNeutral,            0)
  1345.  
  1346. #define        (kFishPerPlayer,                9)
  1347. #define        (kFishPerNeutral,                0)
  1348.  
  1349. #define        (kGoldPerPlayer,                3)
  1350. #define        (kGoldPerNeutral,                0)
  1351.  
  1352. #define        (kOilPerPlayer,                0)
  1353. #define        (kOilPerNeutral,                0)
  1354.  
  1355. #define        (kSteelPerPlayer,                3)
  1356. #define        (kSteelPerNeutral,            0)
  1357.  
  1358. #define        (kStonePerPlayer,                1)
  1359. #define        (kStonePerNeutral,            0)
  1360.  
  1361. #define        (kTreePerPlayer,                0)
  1362. #define        (kTreePerNeutral,                0)
  1363.  
  1364. //////////////////////////////////////////////////////////////////////
  1365. // forest definitions
  1366. #define        (kForestFreeRadius,            7.0)
  1367. #define        (kForestsPerPlayer,            4)
  1368. #define        (kForestChaosLevel,            0.1)
  1369. #define        (kMaxClumpsPerForest,            4)
  1370.  
  1371.  
  1372. #elif Is15Players
  1373. //////////////////////////////////////////////////////////////////////
  1374. // 15 PLAYERS...
  1375. //////////////////////////////////////////////////////////////////////
  1376.  
  1377. //////////////////////////////////////////////////////////////////////
  1378. // terrain definitions
  1379. #define        (kMinIntElevation,                -10)
  1380. #define        (kMaxIntElevation,                12)
  1381. #define        (kElevationScale,                      1)
  1382. #define        (kPercentLand,                    Between(0.45, 0.45))
  1383. #define        (kWaterBorder,                    0)
  1384. #define        (kRiverWidth,                    12)
  1385. #define        (kCoastToDeepWaterPercentage                1.0)
  1386. #define        (kHeightMapChaos,                    Between(12, 25))
  1387.         
  1388. #define        (kMinimumStartPositionToMapEdge        4)
  1389. #define        (kOuterPushFromMapCenter            22)
  1390. #define        (kInnerPushFromMapCenter             0)
  1391.  
  1392. //////////////////////////////////////////////////////////////////////
  1393. // player definitions
  1394. #define        (kMaxAngleBetweenTeamMembers,        45.0)
  1395. #define        (kPlayerInnerRadius,            0.1)
  1396. #define        (kPlayerOuterRadius,            0.99)
  1397. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1398. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  1399. #define        (kPlayerLandChaos,            0.8)
  1400. #define        (kPlayerLandClumps,            1)
  1401. #define        (kPlayerFlatChaos,            0.8)
  1402. #define        (kPlayerFlatClumps,            2)
  1403. #define        (kPlayerTreePercentage,            0.035)
  1404.  
  1405.  
  1406. //////////////////////////////////////////////////////////////////////
  1407. // inner neutral definitions
  1408. #define        (kNeutralInnerRadius,            0.1)
  1409. #define        (kNeutralOuterRadius,            0.55)
  1410. #define        (kNeutralOptimalFactor,            0.7)
  1411. #define        (kNumInnerNeutrals,            Between(0, 0))
  1412. #define        (kInnerNeutralPercentLand,        0.32)
  1413. #define        (kInnerNeutralPercentFlat,        Between(.4, .7))
  1414. #define        (kInnerNeutralTreePercentage,          0.035)
  1415. #define        (kInnerNeutralLandChaos,        0.8)
  1416. #define        (kInnerNeutralLandClumps,        Between(1, 2))
  1417. #define        (kInnerNeutralFlatChaos,        0.8)
  1418. #define        (kInnerNeutralFlatClumps,        2)
  1419.  
  1420.  
  1421. //////////////////////////////////////////////////////////////////////
  1422. // outer neutral definitions
  1423. #define        (kNumOuterNeutrals,            Between(0, 0))
  1424. #define        (kOuterNeutralPercentLand,        0.35)
  1425. #define        (kOuterNeutralPercentFlat,        Between(.4, .7))
  1426. #define        (kOuterNeutralTreePercentage,          0.035)
  1427. #define        (kOuterNeutralLandChaos,        0.8)
  1428. #define        (kOuterNeutralLandClumps,        Between(1, 2))
  1429. #define        (kOuterNeutralFlatChaos,        0.8)
  1430. #define        (kOuterNeutralFlatClumps,        2)
  1431.  
  1432.  
  1433. //////////////////////////////////////////////////////////////////////
  1434. // resource definitions
  1435. #define        (kMaxResourceElevation,            2)
  1436. #define        (kResourceToEdgeDistance,        2)
  1437. #define        (kResourceToWaterDistance,        2)
  1438.  
  1439. #define        (kAnimalPerPlayer,            0)
  1440. #define        (kAnimalPerNeutral,            0)
  1441.  
  1442. #define        (kBerryPerPlayer,                0)
  1443. #define        (kBerryPerNeutral,            0)
  1444.  
  1445. #define        (kFishPerPlayer,                9)
  1446. #define        (kFishPerNeutral,                0)
  1447.  
  1448. #define        (kGoldPerPlayer,                2)
  1449. #define        (kGoldPerNeutral,                0)
  1450.  
  1451. #define        (kOilPerPlayer,                0)
  1452. #define        (kOilPerNeutral,                0)
  1453.  
  1454. #define        (kSteelPerPlayer,                2)
  1455. #define        (kSteelPerNeutral,            0)
  1456.  
  1457. #define        (kStonePerPlayer,                1)
  1458. #define        (kStonePerNeutral,            0)
  1459.  
  1460. #define        (kTreePerPlayer,                0)
  1461. #define        (kTreePerNeutral,                0)
  1462.  
  1463. //////////////////////////////////////////////////////////////////////
  1464. // forest definitions
  1465. #define        (kForestFreeRadius,            7.0)
  1466. #define        (kForestsPerPlayer,            4)
  1467. #define        (kForestChaosLevel,            0.1)
  1468. #define        (kMaxClumpsPerForest,            4)
  1469.  
  1470.  
  1471. #elif Is16Players
  1472. //////////////////////////////////////////////////////////////////////
  1473. // 16 PLAYERS...
  1474. //////////////////////////////////////////////////////////////////////
  1475.  
  1476. //////////////////////////////////////////////////////////////////////
  1477. // terrain definitions
  1478. #define        (kMinIntElevation,                -10)
  1479. #define        (kMaxIntElevation,                12)
  1480. #define        (kElevationScale,                      1)
  1481. #define        (kPercentLand,                    Between(0.45, 0.45))
  1482. #define        (kWaterBorder,                    0)
  1483. #define        (kRiverWidth,                    12)
  1484. #define        (kCoastToDeepWaterPercentage                1.0)
  1485. #define        (kHeightMapChaos,                    Between(12, 25))
  1486.         
  1487. #define        (kMinimumStartPositionToMapEdge        4)
  1488. #define        (kOuterPushFromMapCenter            20)
  1489. #define        (kInnerPushFromMapCenter             0)
  1490.  
  1491. //////////////////////////////////////////////////////////////////////
  1492. // player definitions
  1493. #define        (kMaxAngleBetweenTeamMembers,        45.0)
  1494. #define        (kPlayerInnerRadius,            0.1)
  1495. #define        (kPlayerOuterRadius,            0.99)
  1496. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1497. #define        (kPlayerPercentFlat,            Between(0.65, 0.65))
  1498. #define        (kPlayerLandChaos,            0.8)
  1499. #define        (kPlayerLandClumps,            1)
  1500. #define        (kPlayerFlatChaos,            0.8)
  1501. #define        (kPlayerFlatClumps,            2)
  1502. #define        (kPlayerTreePercentage,            0.035)
  1503.  
  1504.  
  1505. //////////////////////////////////////////////////////////////////////
  1506. // inner neutral definitions
  1507. #define        (kNeutralInnerRadius,            0.1)
  1508. #define        (kNeutralOuterRadius,            0.55)
  1509. #define        (kNeutralOptimalFactor,            0.7)
  1510. #define        (kNumInnerNeutrals,            Between(0, 0))
  1511. #define        (kInnerNeutralPercentLand,        0.32)
  1512. #define        (kInnerNeutralPercentFlat,        Between(.4, .7))
  1513. #define        (kInnerNeutralTreePercentage,          0.035)
  1514. #define        (kInnerNeutralLandChaos,        0.8)
  1515. #define        (kInnerNeutralLandClumps,        Between(1, 2))
  1516. #define        (kInnerNeutralFlatChaos,        0.8)
  1517. #define        (kInnerNeutralFlatClumps,        2)
  1518.  
  1519.  
  1520. //////////////////////////////////////////////////////////////////////
  1521. // outer neutral definitions
  1522. #define        (kNumOuterNeutrals,            Between(0, 0))
  1523. #define        (kOuterNeutralPercentLand,        0.35)
  1524. #define        (kOuterNeutralPercentFlat,        Between(.4, .7))
  1525. #define        (kOuterNeutralTreePercentage,          0.035)
  1526. #define        (kOuterNeutralLandChaos,        0.8)
  1527. #define        (kOuterNeutralLandClumps,        Between(1, 2))
  1528. #define        (kOuterNeutralFlatChaos,        0.8)
  1529. #define        (kOuterNeutralFlatClumps,        2)
  1530.  
  1531.  
  1532. //////////////////////////////////////////////////////////////////////
  1533. // resource definitions
  1534. #define        (kMaxResourceElevation,            2)
  1535. #define        (kResourceToEdgeDistance,        2)
  1536. #define        (kResourceToWaterDistance,        2)
  1537.  
  1538. #define        (kAnimalPerPlayer,            0)
  1539. #define        (kAnimalPerNeutral,            0)
  1540.  
  1541. #define        (kBerryPerPlayer,                0)
  1542. #define        (kBerryPerNeutral,            0)
  1543.  
  1544. #define        (kFishPerPlayer,                9)
  1545. #define        (kFishPerNeutral,                0)
  1546.  
  1547. #define        (kGoldPerPlayer,                2)
  1548. #define        (kGoldPerNeutral,                0)
  1549.  
  1550. #define        (kOilPerPlayer,                0)
  1551. #define        (kOilPerNeutral,                0)
  1552.  
  1553. #define        (kSteelPerPlayer,                2)
  1554. #define        (kSteelPerNeutral,            0)
  1555.  
  1556. #define        (kStonePerPlayer,                1)
  1557. #define        (kStonePerNeutral,            0)
  1558.  
  1559. #define        (kTreePerPlayer,                0)
  1560. #define        (kTreePerNeutral,                0)
  1561.  
  1562. //////////////////////////////////////////////////////////////////////
  1563. // forest definitions
  1564. #define        (kForestFreeRadius,            7.0)
  1565. #define        (kForestsPerPlayer,            4)
  1566. #define        (kForestChaosLevel,            0.1)
  1567. #define        (kMaxClumpsPerForest,            4)
  1568.  
  1569.  
  1570.  
  1571. //////////////////////////////////////////////////////////////////////
  1572. // End of if...elif... command
  1573. #endif
  1574.  
  1575. #endif        // NOTDEFINED(LARGE_ISLANDS_GIGANTIC_RMV)
  1576.